// ========== 重要提示 ========== //
// AI 助手请注意：
// 1. 请不要修改此页面模板文件，此文件是项目代码风格的权威参考标准
// 2. 您在生成任何页面代码时，必须完全严格地遵循此模板中的所有代码风格、缩进规范和编码惯例
// 3. 此模板中的每一个空格、换行、缩进、注释格式都代表了项目的标准，必须100%遵循
// 4. 任何与此模板不一致的代码都会被视为不规范代码
// 5. 移除所有方法前的private或public关键字
// 6. 清理所有注释掉的代码和未使用的变量、函数
// ============================= //
/*
 * @Author: AI Assistant
 * @Date: 2024-05-07 15:30:00
 * @Last Modified by: AI Assistant
 * @Last Modified time: 2024-05-07 15:30:00
 */

// PC页面模板Store文件

// 每个页面都要对应配套一个api文件，无论是否用到
// 由于是模板，这里使用模拟的api导入路径
import pageTemplateApi from '@/api/pageTemplateApi';

// 数据类型必须都要写到@/types/type这个公共文件中
// import { PageTemplateStoreData } from '../../../types/type';

// 本地定义接口以避免类型错误
interface PageTemplateStoreData {
  id?: number;
  name?: string;
}

// 使用mobx进行状态管理
import { makeAutoObservable } from 'mobx';

/**
 * PC页面模板的状态管理类
 * 遵循项目统一的开发规范：
 * 1. 类名与文件名保持一致
 * 2. 每个状态值都有对应的设置函数
 * 3. 状态只能通过setter方法修改，不能直接修改
 * 4. 异步操作使用async/await
 * 5. 方法前不添加private或public关键字
 */
class PageTemplateStore {
    constructor() {
        // 初始化mobx观察，使用deep: false提高性能
        makeAutoObservable(this, {}, { deep: false });
    }

    // 基本类型状态值示例
    value1 = 1;

    /** 设置value1的值 */
    setValue1(value1: number) {
        this.value1 = value1;
    }

    // 另一个基本类型状态值示例
    value2 = 2;

    /** 设置value2的值 */
    setValue2(value2: number) {
        this.value2 = value2;
        // 可以在setter中调用其他setter方法
        this.setValue1(value2);
    }

    // 对象或数组类型的状态值示例
    value3: Array<PageTemplateStoreData> = [];

    // 加载状态
    loading = false;

    /** 设置加载状态 */
    setLoading(loading: boolean) {
        this.loading = loading;
    }

    // 搜索关键词
    searchKeyword = '';

    /** 设置搜索关键词 */
    setSearchKeyword(keyword: string) {
        this.searchKeyword = keyword;
    }

    // 当前页码
    currentPage = 1;

    /** 设置当前页码 */
    setCurrentPage(page: number) {
        this.currentPage = page;
    }

    // 每页显示数量
    pageSize = 10;

    /**
     * 设置每页显示数量
     */
    setPageSize(size: number) {
        this.pageSize = size;
        // 切换每页显示数量时，重置到第一页
        this.setCurrentPage(1);
    }

    // 总数据量
    totalCount = 0;

    /** 设置总数据量 */
    setTotalCount(count: number) {
        this.totalCount = count;
    }

    // 选中的项ID列表（用于批量操作）
    selectedItems: number[] = [];

    /** 设置选中的项 */
    setSelectedItems(items: number[]) {
        this.selectedItems = items;
    }

    /** 添加选中项 */
    addSelectedItem(id: number) {
        if (!this.selectedItems.includes(id)) {
            this.selectedItems.push(id);
        }
    }

    /** 移除选中项 */
    removeSelectedItem(id: number) {
        this.selectedItems = this.selectedItems.filter(itemId => itemId !== id);
    }

    /** 清空选中项 */
    clearSelectedItems() {
        this.selectedItems = [];
    }

    /**
     * 从服务器获取数据的示例方法
     * 模拟API调用，实际项目中会替换为真实的API请求
     * @param isSearch 是否为搜索操作
     */
    async getValue3(isSearch = false) {
        try {
            this.setLoading(true);
            
            // 模拟API调用成功的响应
            await new Promise(resolve => setTimeout(resolve, 500)); // 模拟网络延迟
            
            // 模拟数据
            let mockData: PageTemplateStoreData[] = [];
            const baseId = (this.currentPage - 1) * this.pageSize;
            const itemCount = Math.min(this.pageSize, 20); // 模拟最多20条数据
            
            for (let i = 0; i < itemCount; i++) {
                const id = baseId + i + 1;
                // 如果有搜索关键词，只返回包含关键词的数据
                if (this.searchKeyword && !`PC模板数据项${id}`.includes(this.searchKeyword)) {
                    continue;
                }
                mockData.push({
                    id,
                    name: `PC模板数据项${id}`
                });
            }
            
            this.value3 = mockData;
            this.setTotalCount(20); // 模拟总数据量为20条
            
            // 如果是搜索操作，清空选中项
            if (isSearch) {
                this.clearSelectedItems();
            }
            
            return true;
        } catch (error) {
            console.error('获取数据失败:', error);
            return false;
        } finally {
            this.setLoading(false);
        }
    }

    /** 执行搜索操作 */
    async doSearch() {
        this.setCurrentPage(1); // 搜索时重置到第一页
        return await this.getValue3(true);
    }

    /**
     * 执行重置操作
     */
    async doReset() {
        this.setSearchKeyword('');
        this.setCurrentPage(1);
        this.clearSelectedItems();
        return await this.getValue3();
    }

    /** 切换到上一页 */
    async prevPage() {
        if (this.currentPage > 1) {
            this.setCurrentPage(this.currentPage - 1);
            this.clearSelectedItems();
            return await this.getValue3();
        }
        return false;
    }

    /** 切换到下一页 */
    async nextPage() {
        const totalPages = Math.ceil(this.totalCount / this.pageSize);
        if (this.currentPage < totalPages) {
            this.setCurrentPage(this.currentPage + 1);
            this.clearSelectedItems();
            return await this.getValue3();
        }
        return false;
    }

    /** 添加新数据项 */
    async addDataItem(item: PageTemplateStoreData) {
        try {
            this.setLoading(true);
            
            // 模拟添加数据
            await new Promise(resolve => setTimeout(resolve, 300));
            this.value3.push({ ...item });
            this.setTotalCount(this.totalCount + 1);
            
            return true;
        } catch (error) {
            console.error('添加数据失败:', error);
            return false;
        } finally {
            this.setLoading(false);
        }
    }

    /** 更新指定ID的数据项 */
    async updateDataItem(id: number, updatedData: Partial<PageTemplateStoreData>) {
        try {
            this.setLoading(true);
            
            // 模拟更新数据
            await new Promise(resolve => setTimeout(resolve, 300));
            const index = this.value3.findIndex(item => item.id === id);
            if (index !== -1) {
                this.value3[index] = { ...this.value3[index], ...updatedData };
            }
            
            return true;
        } catch (error) {
            console.error('更新数据失败:', error);
            return false;
        } finally {
            this.setLoading(false);
        }
    }

    /** 删除指定ID的数据项 */
    async deleteDataItem(id: number) {
        try {
            this.setLoading(true);
            
            // 模拟删除数据
            await new Promise(resolve => setTimeout(resolve, 300));
            this.value3 = this.value3.filter(item => item.id !== id);
            this.setTotalCount(Math.max(0, this.totalCount - 1));
            
            // 从选中项中移除
            this.removeSelectedItem(id);
            
            return true;
        } catch (error) {
            console.error('删除数据失败:', error);
            return false;
        } finally {
            this.setLoading(false);
        }
    }

    /** 批量删除数据项 */
    async batchDeleteDataItems(ids: number[]) {
        try {
            this.setLoading(true);
            
            // 模拟批量删除数据
            await new Promise(resolve => setTimeout(resolve, 500));
            this.value3 = this.value3.filter(item => item.id !== undefined && !ids.includes(item.id));
            this.setTotalCount(Math.max(0, this.totalCount - ids.length));
            
            // 清空选中项
            this.clearSelectedItems();
            
            return true;
        } catch (error) {
            console.error('批量删除数据失败:', error);
            return false;
        } finally {
            this.setLoading(false);
        }
    }

    /** 清空所有数据 */
    clearData() {
        this.value3 = [];
        this.setValue1(1);
        this.setValue2(2);
        this.setCurrentPage(1);
        this.setSearchKeyword('');
        this.clearSelectedItems();
        this.setTotalCount(0);
    }
}

// 创建并导出store实例
// 实例名称与文件名保持一致（去掉后缀）
const pageTemplateStore = new PageTemplateStore();

export default pageTemplateStore;